home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / var / lib / python-support / python2.6 / drv_libxml2.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-10-12  |  11.0 KB  |  297 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. ''' A SAX2 driver for libxml2, on top of it\'s XmlReader API
  5.  
  6. USAGE
  7.     # put this file (drv_libxml2.py) in PYTHONPATH
  8.     import xml.sax
  9.     reader = xml.sax.make_parser(["drv_libxml2"])
  10.     # ...and the rest is standard python sax.
  11.  
  12. CAVEATS
  13.     - Lexical handlers are supported, except for start/endEntity
  14.       (waiting for XmlReader.ResolveEntity) and start/endDTD
  15.     - Error callbacks are not exactly synchronous, they tend
  16.       to be invoked before the corresponding content callback,
  17.       because the underlying reader interface parses
  18.       data by chunks of 512 bytes
  19.     
  20. TODO
  21.     - search for TODO
  22.     - some ErrorHandler events (warning)
  23.     - some ContentHandler events (setDocumentLocator, skippedEntity)
  24.     - EntityResolver (using libxml2.?)
  25.     - DTDHandler (if/when libxml2 exposes such node types)
  26.     - DeclHandler (if/when libxml2 exposes such node types)
  27.     - property_xml_string?
  28.     - feature_string_interning?
  29.     - Incremental parser
  30.     - additional performance tuning:
  31.       - one might cache callbacks to avoid some name lookups
  32.       - one might implement a smarter way to pass attributes to startElement
  33.         (some kind of lazy evaluation?)
  34.       - there might be room for improvement in start/endPrefixMapping
  35.       - other?
  36.  
  37. '''
  38. __author__ = u'St√©phane Bidoul <sbi@skynet.be>'
  39. __version__ = '0.3'
  40. import codecs
  41. from types import StringType, UnicodeType
  42. StringTypes = (StringType, UnicodeType)
  43. from xml.sax._exceptions import *
  44. from xml.sax import xmlreader, saxutils
  45. from xml.sax.handler import feature_namespaces, feature_namespace_prefixes, feature_string_interning, feature_validation, feature_external_ges, feature_external_pes, property_lexical_handler, property_declaration_handler, property_dom_node, property_xml_string
  46. _decoder = codecs.lookup('utf8')[1]
  47.  
  48. def _d(s):
  49.     if s is None:
  50.         return s
  51.     return _decoder(s)[0]
  52.  
  53.  
  54. try:
  55.     import libxml2
  56. except ImportError:
  57.     e = None
  58.     raise SAXReaderNotAvailable('libxml2 not available: import error was: %s' % e)
  59.  
  60.  
  61. class Locator(xmlreader.Locator):
  62.     '''SAX Locator adapter for libxml2.xmlTextReaderLocator'''
  63.     
  64.     def __init__(self, locator):
  65.         self._Locator__locator = locator
  66.  
  67.     
  68.     def getColumnNumber(self):
  69.         '''Return the column number where the current event ends.'''
  70.         return -1
  71.  
  72.     
  73.     def getLineNumber(self):
  74.         '''Return the line number where the current event ends.'''
  75.         return self._Locator__locator.LineNumber()
  76.  
  77.     
  78.     def getPublicId(self):
  79.         '''Return the public identifier for the current event.'''
  80.         pass
  81.  
  82.     
  83.     def getSystemId(self):
  84.         '''Return the system identifier for the current event.'''
  85.         return self._Locator__locator.BaseURI()
  86.  
  87.  
  88.  
  89. class LibXml2Reader(xmlreader.XMLReader):
  90.     
  91.     def __init__(self):
  92.         xmlreader.XMLReader.__init__(self)
  93.         self._LibXml2Reader__ns = 0
  94.         self._LibXml2Reader__nspfx = 0
  95.         self._LibXml2Reader__validate = 0
  96.         self._LibXml2Reader__extparams = 1
  97.         self._LibXml2Reader__parsing = 0
  98.         self._LibXml2Reader__lex_handler = None
  99.         self._LibXml2Reader__decl_handler = None
  100.         self._LibXml2Reader__errors = None
  101.  
  102.     
  103.     def _errorHandler(self, arg, msg, severity, locator):
  104.         if self._LibXml2Reader__errors is None:
  105.             self._LibXml2Reader__errors = []
  106.         
  107.         self._LibXml2Reader__errors.append((severity, SAXParseException(msg, None, Locator(locator))))
  108.  
  109.     
  110.     def _reportErrors(self, fatal):
  111.         for severity, exception in self._LibXml2Reader__errors:
  112.             if severity in (libxml2.PARSER_SEVERITY_VALIDITY_WARNING, libxml2.PARSER_SEVERITY_WARNING):
  113.                 self._err_handler.warning(exception)
  114.                 continue
  115.             if fatal and exception is self._LibXml2Reader__errors[-1][1]:
  116.                 self._err_handler.fatalError(exception)
  117.                 continue
  118.             self._err_handler.error(exception)
  119.         
  120.         self._LibXml2Reader__errors = None
  121.  
  122.     
  123.     def parse(self, source):
  124.         self._LibXml2Reader__parsing = 1
  125.         
  126.         try:
  127.             if type(source) in StringTypes:
  128.                 reader = libxml2.newTextReaderFilename(source)
  129.             else:
  130.                 source = saxutils.prepare_input_source(source)
  131.                 input = libxml2.inputBuffer(source.getByteStream())
  132.                 reader = input.newTextReader(source.getSystemId())
  133.             reader.SetErrorHandler(self._errorHandler, None)
  134.             if self._LibXml2Reader__extparams:
  135.                 reader.SetParserProp(libxml2.PARSER_LOADDTD, 1)
  136.                 reader.SetParserProp(libxml2.PARSER_DEFAULTATTRS, 1)
  137.                 reader.SetParserProp(libxml2.PARSER_SUBST_ENTITIES, 1)
  138.                 reader.SetParserProp(libxml2.PARSER_VALIDATE, self._LibXml2Reader__validate)
  139.             else:
  140.                 reader.SetParserProp(libxml2.PARSER_LOADDTD, 0)
  141.             if self._LibXml2Reader__ns:
  142.                 attributesNSImpl = xmlreader.AttributesNSImpl({ }, { })
  143.             else:
  144.                 attributesImpl = xmlreader.AttributesImpl({ })
  145.             prefixes = []
  146.             self._cont_handler.startDocument()
  147.             while None:
  148.                 r = reader.Read()
  149.                 if r == 1:
  150.                     if self._LibXml2Reader__errors is not None:
  151.                         self._reportErrors(0)
  152.                     
  153.                 elif r == 0:
  154.                     if self._LibXml2Reader__errors is not None:
  155.                         self._reportErrors(0)
  156.                     
  157.                     break
  158.                 elif self._LibXml2Reader__errors is not None:
  159.                     self._reportErrors(1)
  160.                 else:
  161.                     self._err_handler.fatalError(SAXException('Read failed (no details available)'))
  162.                 break
  163.                 nodeType = reader.NodeType()
  164.                 if nodeType == 1:
  165.                     pass
  166.                 if nodeType == 15:
  167.                     if self._LibXml2Reader__ns:
  168.                         self._cont_handler.endElementNS((_d(reader.NamespaceUri()), _d(reader.LocalName())), _d(reader.Name()))
  169.                         for prefix in prefixes.pop():
  170.                             self._cont_handler.endPrefixMapping(prefix)
  171.                         
  172.                     else:
  173.                         self._cont_handler.endElement(_d(reader.Name()))
  174.                 self._LibXml2Reader__ns
  175.                 if nodeType == 3:
  176.                     self._cont_handler.characters(_d(reader.Value()))
  177.                     continue
  178.                 if nodeType == 13:
  179.                     self._cont_handler.ignorableWhitespace(_d(reader.Value()))
  180.                     continue
  181.                 if nodeType == 14:
  182.                     self._cont_handler.characters(_d(reader.Value()))
  183.                     continue
  184.                 if nodeType == 4:
  185.                     if self._LibXml2Reader__lex_handler is not None:
  186.                         self._LibXml2Reader__lex_handler.startCDATA()
  187.                     
  188.                     self._cont_handler.characters(_d(reader.Value()))
  189.                     if self._LibXml2Reader__lex_handler is not None:
  190.                         self._LibXml2Reader__lex_handler.endCDATA()
  191.                     
  192.                 self._LibXml2Reader__lex_handler is not None
  193.                 if nodeType == 5:
  194.                     if self._LibXml2Reader__lex_handler is not None:
  195.                         self.startEntity(_d(reader.Name()))
  196.                     
  197.                     reader.ResolveEntity()
  198.                     continue
  199.                 if nodeType == 16:
  200.                     if self._LibXml2Reader__lex_handler is not None:
  201.                         self.endEntity(_d(reader.Name()))
  202.                     
  203.                 self._LibXml2Reader__lex_handler is not None
  204.                 if nodeType == 7:
  205.                     self._cont_handler.processingInstruction(_d(reader.Name()), _d(reader.Value()))
  206.                     continue
  207.                 if nodeType == 8:
  208.                     if self._LibXml2Reader__lex_handler is not None:
  209.                         self._LibXml2Reader__lex_handler.comment(_d(reader.Value()))
  210.                     
  211.                 self._LibXml2Reader__lex_handler is not None
  212.                 if nodeType == 10:
  213.                     continue
  214.                 if nodeType == 17:
  215.                     continue
  216.                 if nodeType == 6:
  217.                     continue
  218.                 if nodeType == 12:
  219.                     continue
  220.                 raise SAXException('Unexpected node type %d' % nodeType)
  221.                 continue
  222.                 if r == 0:
  223.                     self._cont_handler.endDocument()
  224.                 
  225.             reader.Close()
  226.         finally:
  227.             self._LibXml2Reader__parsing = 0
  228.  
  229.  
  230.     
  231.     def setDTDHandler(self, handler):
  232.         raise SAXNotSupportedException('DTDHandler not supported')
  233.  
  234.     
  235.     def setEntityResolver(self, resolver):
  236.         raise SAXNotSupportedException('EntityResolver not supported')
  237.  
  238.     
  239.     def getFeature(self, name):
  240.         if name == feature_namespaces:
  241.             return self._LibXml2Reader__ns
  242.         if name == feature_namespace_prefixes:
  243.             return self._LibXml2Reader__nspfx
  244.         if name == feature_validation:
  245.             return self._LibXml2Reader__validate
  246.         if name == feature_external_ges:
  247.             return 1
  248.         if name == feature_external_pes:
  249.             return self._LibXml2Reader__extparams
  250.         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  251.  
  252.     
  253.     def setFeature(self, name, state):
  254.         if self._LibXml2Reader__parsing:
  255.             raise SAXNotSupportedException('Cannot set feature %s while parsing' % name)
  256.         self._LibXml2Reader__parsing
  257.         if name == feature_namespaces:
  258.             self._LibXml2Reader__ns = state
  259.         elif name == feature_namespace_prefixes:
  260.             self._LibXml2Reader__nspfx = state
  261.         elif name == feature_validation:
  262.             self._LibXml2Reader__validate = state
  263.         elif name == feature_external_ges:
  264.             if state == 0:
  265.                 raise SAXNotSupportedException("Feature '%s' not supported" % name)
  266.             state == 0
  267.         elif name == feature_external_pes:
  268.             self._LibXml2Reader__extparams = state
  269.         else:
  270.             raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  271.         return name == feature_namespaces
  272.  
  273.     
  274.     def getProperty(self, name):
  275.         if name == property_lexical_handler:
  276.             return self._LibXml2Reader__lex_handler
  277.         if name == property_declaration_handler:
  278.             return self._LibXml2Reader__decl_handler
  279.         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  280.  
  281.     
  282.     def setProperty(self, name, value):
  283.         if name == property_lexical_handler:
  284.             self._LibXml2Reader__lex_handler = value
  285.         elif name == property_declaration_handler:
  286.             raise SAXNotSupportedException("Property '%s' not supported" % name)
  287.             self._LibXml2Reader__decl_handler = value
  288.         else:
  289.             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  290.         return name == property_lexical_handler
  291.  
  292.  
  293.  
  294. def create_parser():
  295.     return LibXml2Reader()
  296.  
  297.